package com.example.as_sum.util;

import com.example.as_sum.application.AppApplication;
import com.litesuits.orm.LiteOrm;
import com.litesuits.orm.db.assit.QueryBuilder;
import com.litesuits.orm.db.assit.WhereBuilder;
import com.litesuits.orm.db.model.ColumnsValue;
import com.litesuits.orm.db.model.ConflictAlgorithm;

import java.util.HashMap;
import java.util.List;

/**
 * Created by ran on 2016/10/9.
 丰富的基础性增删改查接口支持：save(insert or replace), insert, update, delete, query, mapping...
 以及各种边缘功能并支持冲突算法。

 支持多库，每个数据库文件对应一个DataBase实例，它们共享实体信息，表信息独立。一般单数据库情况下，
 建议自己维护单例DataBase db = LiteOrm.newInstance(context, "dbname")，  减少开销。
 查找时自动构建对象，不需要无参构造函数。

 支持仅更新指定列，支持向指定列灵活（批量）赋值，将无视对象中该属性的真实值。
 自动建表：开发者无需关心数据库以及表细节。

 智能识别数据类型：分别转化为以sqlite支持的TEXT, REAL, INTEGER, BLOB几种数据类型存储。
 智能列探测：如User这个类多加了一个sex标识性别，Archiver将自动添加该列入已经建好的表，以支持新属性。
 实体关系持久化和关系映射：真正实现实体关系映射持久化以及恢复，而开发者只需要在实体的关联属性上标出关系类型即可。
 序列化字段皆可存储：各种ArrayList、Vector等各种容器智能保存及读取。
 丰富的约束性语法支持：NOT NULL, UNIQUE, DEFAULT, COLLATE, CHECK, PRIMARY KEY
 自由灵活的查询：columns, where, roder, limit, having group, etc.
 */
public class DataBaseUtil {
    private static LiteOrm liteOrm;
    public static LiteOrm getInstance() {
        if (liteOrm == null) {
            synchronized (LiteOrm.class) {
                if (liteOrm == null) {
                    liteOrm=LiteOrm.newCascadeInstance(AppApplication.aContext , "course.db" ) ;
                }
            }
        }
        return liteOrm;
    }
    /**
     * 插入一条记录
     * @param t
     */
    public static <T> long insert(T t) {
        return liteOrm.save(t);
    }

    /**
     * 插入所有记录
     * @param list
     */
    public static <T> void insertAll(List<T> list) {
        liteOrm.save(list);
    }

    /**
     * 查询所有
     * @param cla
     * @return
     */
    public static <T> List<T> getQueryAll(Class<T> cla) {
        return liteOrm.query(cla);
    }

    /**
     * 查询  某字段 等于 Value的值
     * @param cla
     * @param field
     * @param value
     * @return
     */
    public static <T> List<T> getQueryByWhere(Class<T> cla, String field, String value) {
        return liteOrm.<T>query(new QueryBuilder(cla).where(field + "=?", value));
    }
    public static  <T> void updateData(Class<T> cla){
        liteOrm.update(cla);
    }

    /**
     * 根据条件查找表中的记录，在更新这条记录的值
     * @param cla  表
     * @param fieid 属性名
     * @param value 值      这是条件
     * @param  map 表示把需要你更新的值传进去 map.put("属性名", "要更新的值");
     * @param <T>
     */
    public static  <T> int updateData(Class<T> cla,String fieid,String value,HashMap<String, Object> map){
        WhereBuilder builder=new WhereBuilder(cla).where(fieid+"=?",value);
        ColumnsValue columnsValue=new ColumnsValue(map);
        //返回更新影响的行数，否则返回-1
        int count=liteOrm.update(builder,columnsValue, ConflictAlgorithm.Fail);
        return count;
    }
    /**
     * 查询  某字段 等于 Value的值  可以指定从1-20，就是分页
     * @param cla
     * @param field
     * @param value
     * @param start
     * @param length
     * @return
     */
    public static <T> List<T> getQueryByWhereLength(Class<T> cla, String field, String value, int start, int length) {
        return liteOrm.<T>query(new QueryBuilder(cla).where(field + "=?", value).limit(start, length));
    }

    /**
     * 删除一个数据
     * @param t
     * @param <T>
     */
    public static <T> void delete( T t){
        liteOrm.delete( t ) ;
    }

    /**
     * 删除一个表
     * @param cla
     * @param <T>
     */
    public static <T> void delete( Class<T> cla ){
        liteOrm.delete( cla ) ;
    }

    /**
     * 删除集合中的数据
     * @param list
     * @param <T>
     */
    public static <T> void deleteList( List<T> list ){
        liteOrm.delete( list ) ;
    }

    /**
     * 删除数据库
     */
    public static void deleteDatabase(){
        liteOrm.deleteDatabase() ;

    }
}
